home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / pao / towns / cdplay / src / key.c < prev    next >
Text File  |  1991-10-18  |  40KB  |  1,315 lines
  1. /* << High C V1.4 & 386ASM V2.0 >> ********************************************
  2. **
  3. **    CD PLAYER ｷｰﾎﾞｰﾄﾞ ｲﾝﾀｰﾌｪｰｽ ﾙｰﾁﾝ
  4. **
  5. **    1991.03.22 : CREATE
  6. **    1991.03.23 : FINISH
  7. **
  8. **    < HISTORY >
  9. **    1991.03.22 : CREATE
  10. **
  11. **    < note > : TABS = 4
  12. **
  13. **    All Rights Reserved, Copyright (C) Y.Hirata 1991.
  14. **
  15. **    Programmed by Y.Hirata ( Nifty ID : NAB03321 )
  16. **
  17. ******************************************************************************/
  18.  
  19. #include <fmc.h>
  20. #include "key.h"
  21. #include "elevol.h"
  22. #include "sndplay.h"
  23. #include "cdpn.h"
  24. #include "tape.h"
  25.  
  26. /*-----------------------------------------------------------------------------
  27. **    ｷｰﾘﾋﾟｰﾄ制御(待ち時間)に使用します.
  28. -----------------------------------------------------------------------------*/
  29. extern SOFT_timer( unsigned ) ;
  30.  
  31. /*-----------------------------------------------------------------------------
  32. **    いわゆる隠し機能に相当します♪
  33. -----------------------------------------------------------------------------*/
  34. extern char    CDDA_FLG_stop ;                    /*  ﾌﾟﾛｸﾞﾗﾑ終了時にSTOPする？    */
  35.  
  36. /*-----------------------------------------------------------------------------
  37. **    停止中/NOT READY中の未ｱｸｾｽﾁｪｯｸに使用します.
  38. -----------------------------------------------------------------------------*/
  39. extern char    Noaflg ;                        /*  停止中にｱｸｾｽしたか？        */
  40.  
  41. /********************************  ｷｰ ON ﾁｪｯｸ  *******************************/
  42. int KEY_test( char *matrix,char keyadrs )
  43. /*=============================================================================
  44. **    ｷｰﾏﾄﾘｸｽ中で、指定されたｷｰｱﾄﾞﾚｽのｷｰが押されているかどうかﾁｪｯｸする.
  45. **
  46. **    < INPUT  > : ｷｰﾏﾄﾘｸｽ情報 , ｷｰｱﾄﾞﾚｽ
  47. **    < OUTPUT > : なし
  48. **    < RETURN > : ｷｰON ならば 真値 , ｷｰOFF ならば 偽値.
  49. =============================================================================*/
  50. {
  51.     unsigned char    testbit ;
  52.     int        c ;
  53.     int        byteoff ;
  54.  
  55.     testbit = 0x01 ;
  56.     for ( c=0; c<(keyadrs%8); c++ ) testbit <<= 1 ;
  57.     byteoff = keyadrs / 8 ;
  58.     if ( (matrix[byteoff] & testbit) == testbit ) return( TRUE ) ;
  59.  
  60.     return( FALSE ) ;
  61. }
  62.  
  63. /******************************  ｷｰBREAK 待ち  *******************************/
  64. void KEY_break( char keyadrs )
  65. /*=============================================================================
  66. **    指定されたｷｰｱﾄﾞﾚｽのｷｰが放されるまで待つ.
  67. **
  68. **    < INPUT  > : ｷｰｱﾄﾞﾚｽ
  69. **    < OUTPUT > : なし
  70. **    < RETURN > : なし
  71. =============================================================================*/
  72. {
  73.     char    matrix[16] ;
  74.  
  75.     do {
  76.         KYB_clrbuf() ;
  77.         KYB_matrix( matrix ) ;
  78.     } while ( KEY_test( matrix,keyadrs ) ) ;
  79.  
  80. }
  81.  
  82. /*******************************  ｷｰ押下ﾁｪｯｸ  ********************************/
  83. int KEY_hitchk( void )
  84. /*=============================================================================
  85. **    ｷｰﾎﾞｰﾄﾞが押されたかどうかﾁｪｯｸする.
  86. **
  87. **    < INPUT  > : なし
  88. **    < OUTPUT > : なし
  89. **    < RETURN > : ｷｰ入力ありならば 真値 , なしならば 偽値.
  90. =============================================================================*/
  91. {
  92.     char    matrix[16] ;
  93.     char    keyon ;
  94.     int        c ;
  95.  
  96.     KYB_matrix( matrix ) ;
  97.  
  98.     keyon = FALSE ;
  99.     for ( c=0; c<16; c++ ) {
  100.         if ( matrix[c] ) {
  101.             keyon = TRUE ;
  102.             break ;
  103.         }
  104.     }
  105.  
  106.     return( keyon ) ;
  107. }
  108.  
  109. /****************************  ｷｰ押下ﾁｪｯｸ(ﾏﾄﾘｸｽ)  ****************************/
  110. int KEY_matrix_check( char *matrix )
  111. /*=============================================================================
  112. **    ｷｰﾎﾞｰﾄﾞが押されたかどうかﾁｪｯｸする.
  113. **
  114. **    < INPUT  > : ｷｰﾏﾄﾘｸｽ情報
  115. **    < OUTPUT > : なし
  116. **    < RETURN > : ｷｰ入力ありならば 真値 , なしならば 偽値.
  117. =============================================================================*/
  118. {
  119.     char    keyon ;
  120.     int        c ;
  121.  
  122.     keyon = FALSE ;
  123.     for ( c=0; c<16; c++ ) {
  124.         if ( matrix[c] ) {
  125.             keyon = TRUE ;
  126.             break ;
  127.         }
  128.     }
  129.  
  130.     return( keyon ) ;
  131. }
  132.  
  133. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  134. void KEY_selectexit( char key )
  135. /*=============================================================================
  136. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (終了処理)
  137. **
  138. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  139. **    < OUTPUT > : なし
  140. **    < RETURN > : なし
  141. **
  142. **    ★[CDPN.C]<event> の EXIT と同じ処理であること.
  143. =============================================================================*/
  144. {
  145.     int        evno ;
  146.  
  147. /*-----------------------------------------------------------------------------
  148. **    ｽｲｯﾁ ON 表示
  149. -----------------------------------------------------------------------------*/
  150.     dispmouse( FALSE ) ;
  151.     evno = SW_EXIT + SWVAL ;
  152.     dispevent( evno,TRUE ) ;
  153.  
  154. /*-----------------------------------------------------------------------------
  155. **    ｽｲｯﾁ 操作(実行)
  156. -----------------------------------------------------------------------------*/
  157.     switch ( key ) {
  158.     case KEY_Q :
  159.     case KEY_E :
  160.         CDDA_FLG_stop = FALSE ;
  161.         break ;
  162.     case KEY_BREAK :
  163.         CDDA_FLG_stop = TRUE ;
  164.     }
  165.  
  166.     SNDPLAY_play( EXIT_CH,EXIT_SND ) ;
  167.     /*    ●● EJECT SWITCH ON ●●    */
  168.     CDDA_switch( CDDA_SW_EXIT ) ;
  169.     dispevent( evno,FALSE ) ;
  170.     mossetpos( evno ) ;
  171. }
  172.  
  173. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  174. void KEY_selectstop( char key )
  175. /*=============================================================================
  176. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (停止処理)
  177. **
  178. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  179. **    < OUTPUT > : なし
  180. **    < RETURN > : なし
  181. **
  182. **    ★[CDPN.C]<event-selectstop> の STOP/PAUSE と同じ処理であること.
  183. =============================================================================*/
  184. {
  185.     int        evno ;
  186.     int        c ;
  187.  
  188.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  189.  
  190. /*-----------------------------------------------------------------------------
  191. **    ｽｲｯﾁ ON 表示
  192. -----------------------------------------------------------------------------*/
  193.     dispmouse( FALSE ) ;
  194.     switch ( key ) {
  195.     case KEY_ESC :
  196.         evno = SW_STOP + SWVAL ;
  197.         break ;
  198.     case KEY_SPACE :
  199.     case TKEY_EQU :
  200.         evno = SW_PAUSE + SWVAL ;
  201.     }
  202.     dispevent( evno,TRUE ) ;
  203.  
  204. /*-----------------------------------------------------------------------------
  205. **    ｽｲｯﾁ 操作(実行)
  206. -----------------------------------------------------------------------------*/
  207.     switch ( key ) {
  208.     case KEY_ESC :
  209. /*-----------------------------------------------------------------------------
  210. **    ●●●  STOP  ●●●
  211. -----------------------------------------------------------------------------*/
  212.         Flg.pause   = FALSE ;
  213.         Flg.shuffle = FALSE ;
  214.         Flg.program = FALSE ;
  215. /*-----------------------------------------------------------------------------
  216. **    ﾌﾟﾛｸﾞﾗﾑﾓｰﾄﾞ時に停止中ならばﾌﾟﾛｸﾞﾗﾑ設定曲をｸﾘｱする｡
  217. -----------------------------------------------------------------------------*/
  218.         if ( Playmode == SW_PROGRAM && CDDA_NOW_status == CDDA_STAT_STOP ) {
  219.             for ( c=0; c<CDDA_MAX_TRACK; c++ ) {
  220.                 Prginf[c] = ZERO ;
  221.                 Prgcnt[c] = ZERO ;
  222.             }
  223.             Flg.tape = FALSE ;
  224.             disptocmode( SW_PROGRAM,DUMMY ) ;
  225.             disptime( ZERO,TM_NODISP ) ;
  226.             /*    ●● STOP SWITCH ON ●●    */
  227.             CDDA_switch( CDDA_SW_STOP ) ;
  228.             dispmsgclear() ;
  229.             dispprogramtime() ;
  230.         }
  231.         if ( CDDA_NOW_status == CDDA_STAT_PLAY ||
  232.                 CDDA_NOW_status == CDDA_STAT_PAUSE ) {
  233.             /*    ●● STOP SWITCH ON ●●    */
  234.             CDDA_switch( CDDA_SW_STOP ) ;
  235.         }
  236.         dispshuffle( FALSE ) ;
  237.         disppause( FALSE ) ;
  238.         dispplay( FALSE ) ;
  239.         dispevent( evno,FALSE ) ;
  240.         mossetpos( SW_STOP+SWVAL ) ;
  241.         break ;
  242.     case KEY_SPACE :
  243.     case TKEY_EQU :
  244. /*-----------------------------------------------------------------------------
  245. **    ●●●  PAUSE  ●●●
  246. -----------------------------------------------------------------------------*/
  247.         if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) {
  248.             dispevent( evno,FALSE ) ;
  249.             break ;
  250.         }
  251.         if ( Playmode == SW_PROGRAM && CDDA_TOTAL_program == ZERO ) {
  252.             dispevent( evno,FALSE ) ;
  253.             break ;
  254.         }
  255.         if ( Flg.pause ) {
  256.             Flg.pause = FALSE ;
  257.         } else {
  258.             Flg.pause = TRUE ;
  259.             dispplay( TRUE ) ;
  260.         }
  261.         disppause( Flg.pause ) ;
  262.         /*    ●● PAUSE SWITCH ON/OFF ●●    */
  263.         CDDA_switch( CDDA_SW_PAUSE ) ;
  264.         mossetpos( SW_PAUSE+SWVAL ) ;
  265.     }
  266. }
  267.  
  268. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  269. void KEY_selectmode( char key )
  270. /*=============================================================================
  271. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (ﾓｰﾄﾞ選択処理)
  272. **
  273. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  274. **    < OUTPUT > : なし
  275. **    < RETURN > : なし
  276. **
  277. **    ★[CDPN.C]<event> の PROGRAM/SINGLE/CONTINUE / REPEAT / TIME と同じ処理
  278. **    であること.
  279. =============================================================================*/
  280. {
  281.     int        evno ;
  282.  
  283.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  284.  
  285. /*-----------------------------------------------------------------------------
  286. **    ｽｲｯﾁ ON 表示
  287. -----------------------------------------------------------------------------*/
  288.     dispmouse( FALSE ) ;
  289.     switch ( key ) {
  290.     case KEY_P :
  291.         evno = SW_PROGRAM + SWVAL ;
  292.         break ;
  293.     case KEY_S :
  294.         evno = SW_SINGLE + SWVAL ;
  295.         break ;
  296.     case KEY_C :
  297.         evno = SW_CONTINUE + SWVAL ;
  298.         break ;
  299.     case KEY_R :
  300.         evno = SW_REPEAT + SWVAL ;
  301.         break ;
  302.     case KEY_T :
  303.         evno = SW_TIME + SWVAL ;
  304.     }
  305.     dispevent( evno,TRUE ) ;
  306.  
  307. /*-----------------------------------------------------------------------------
  308. **    ｽｲｯﾁ 操作(実行)
  309. -----------------------------------------------------------------------------*/
  310.     switch ( key ) {
  311.     case KEY_P :
  312.     case KEY_S :
  313.     case KEY_C :
  314. /*-----------------------------------------------------------------------------
  315. **    ●●●  演奏ﾓｰﾄﾞ  ●●●
  316. -----------------------------------------------------------------------------*/
  317.         selectmode( evno-SWVAL ) ;
  318.         mossetpos( evno ) ;
  319.         break ;
  320.     case KEY_R :
  321. /*-----------------------------------------------------------------------------
  322. **    ●●●  REPEAT  ●●●
  323. -----------------------------------------------------------------------------*/
  324.         if ( Flg.repeat ) {
  325.             Flg.repeat = FALSE ;
  326.         } else {
  327.             Flg.repeat = TRUE ;
  328.         }
  329.         /*    ●● REPEAT SWITCH ON/OFF ●●    */
  330.         CDDA_switch( CDDA_SW_REPEAT ) ;
  331.         disprepeat( Flg.repeat ) ;
  332.         mossetpos( SW_REPEAT+SWVAL ) ;
  333.         break ;
  334.     case KEY_T :
  335. /*-----------------------------------------------------------------------------
  336. **    ●●●  TIME  ●●●
  337. -----------------------------------------------------------------------------*/
  338.         if ( CDDA_NOW_status != CDDA_STAT_PLAY &&
  339.                 CDDA_NOW_status != CDDA_STAT_PAUSE ) break ;
  340.         switch ( Timemode ) {
  341.         case TM_TR_CLOCK :
  342.             Timemode = TM_TR_TIME ;
  343.             break ;
  344.         case TM_TR_TIME :
  345.             Timemode = TM_DISC_CLOCK ;
  346.             break ;
  347.         case TM_DISC_CLOCK :
  348.             Timemode = TM_DISC_TIME ;
  349.             break ;
  350.         case TM_DISC_TIME :
  351.             Timemode = TM_TR_CLOCK ;
  352.             break ;
  353.         default :
  354.             Timemode = TM_TR_CLOCK ;
  355.         }
  356. /*-----------------------------------------------------------------------------
  357. **    Flg.prgchk が真値だと、時間表示されないので、FALSEにし待ち時間をｸﾘｱする.
  358. -----------------------------------------------------------------------------*/
  359.         Flg.prgchk = FALSE ;
  360.         Tcount2 = PRG_WAIT + 1 ;
  361.         disptime( CDDA_NOW_musicno,Timemode ) ;
  362.     }
  363. }
  364.  
  365. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  366. void KEY_selectonmusic( int no )
  367. /*=============================================================================
  368. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (演奏曲指定処理)
  369. **
  370. **    < INPUT  > : 曲番号
  371. **    < OUTPUT > : なし
  372. **    < RETURN > : なし
  373. **
  374. **    ★[CDPN.C]<event-selectmusic> と同じ処理であること.
  375. =============================================================================*/
  376. {
  377.     int        ret ;
  378.  
  379.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  380.  
  381.     if ( Playmode == SW_PROGRAM ) {
  382.         /*    ●● 曲番号 ON ●●    */
  383.         ret = CDDA_switch( no ) ;
  384.         if ( !ret ) {
  385. /*-----------------------------------------------------------------------------
  386. **    ﾌﾟﾛｸﾞﾗﾑ曲の登録時には、時間表示は、TM_TR_CLOCK とする.
  387. **    また、CHECK時同様ﾌﾟﾛｸﾞﾗﾑ曲確認中表示である旨を ﾌﾗｸﾞｾｯﾄ する.
  388. **    曲の登録作業は、checkmusic() で行う.
  389. -----------------------------------------------------------------------------*/
  390.             Timemode   = TM_TR_CLOCK ;
  391.             Flg.prgchk = TRUE ;
  392.             checkmusic( no ) ;
  393.             disptime( no,Timemode ) ;
  394.             TAPE_check() ;
  395.             dispprogramtime() ;
  396.         }
  397.     } else {
  398.         disptime( ZERO,TM_NODISP ) ;
  399.         checkmusic( no ) ;
  400.         /*    ●● 曲番号 ON ●●    */
  401.         if ( !CDDA_switch( no ) ) {
  402.             dispplay( TRUE ) ;
  403.             Flg.playon = TRUE ;
  404.             if ( Flg.shuffle ) {
  405.                 Flg.shuffle = FALSE ;
  406.                 dispshuffle( FALSE ) ;
  407.                 disptocmode( SW_CONTINUE,no ) ;
  408.             }
  409.         } else {
  410. /*-----------------------------------------------------------------------------
  411. **    指定された曲が演奏できなかった時には、PLAYﾎﾞﾀﾝを OFF表示する.
  412. -----------------------------------------------------------------------------*/
  413.             switch ( CDDA_NOW_status ) {
  414.             case CDDA_STAT_PLAY :
  415.             case CDDA_STAT_PAUSE :
  416.                 break ;
  417.             default :
  418.                 dispplay( FALSE ) ;
  419.                 dispmusicno( no,FALSE ) ;
  420.             }
  421.         }
  422.         disptime( no,Timemode ) ;
  423. /*-----------------------------------------------------------------------------
  424. **    PAUSE中に曲番号が指定された時には、ﾏｳｽ を PLAYﾎﾞﾀﾝに移動しておく.
  425. -----------------------------------------------------------------------------*/
  426.         if ( CDDA_NOW_status == CDDA_STAT_PAUSE ) {
  427.             mossetpos( SW_PLAY+SWVAL ) ;
  428.         }
  429.     }
  430. }
  431.  
  432. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  433. void KEY_selectplay( char key )
  434. /*=============================================================================
  435. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (演奏開始処理)
  436. **
  437. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  438. **    < OUTPUT > : なし
  439. **    < RETURN > : なし
  440. **
  441. **    ★[CDPN.C]<event-selectplay>と同じ処理であること.
  442. =============================================================================*/
  443. {
  444.     int        evno ;
  445.     int        no ;
  446.     int        c ;
  447.     char    flg ;
  448.  
  449.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  450.  
  451. /*-----------------------------------------------------------------------------
  452. **    ｽｲｯﾁ ON 表示
  453. -----------------------------------------------------------------------------*/
  454.     dispmouse( FALSE ) ;
  455.     switch ( key ) {
  456.     case KEY_CR :
  457.     case TKEY_CR :
  458. /*-----------------------------------------------------------------------------
  459. **    ●●●  曲番号指定 / PLAY  ●●●
  460. -----------------------------------------------------------------------------*/
  461.         if ( XORno ) {
  462.             KEY_selectonmusic( XORno ) ;
  463.             return ;
  464.         }
  465.     case KEY_EXEC :
  466.         evno = SW_PLAY + SWVAL ;
  467.         break ;
  468.     case KEY_S :
  469.         evno = SW_SHUFFLE + SWVAL ;
  470.     }
  471.     dispevent( evno,TRUE ) ;
  472.  
  473. /*-----------------------------------------------------------------------------
  474. **    ｽｲｯﾁ 操作(実行)
  475. -----------------------------------------------------------------------------*/
  476.     switch ( key ) {
  477.     case KEY_CR :
  478.     case KEY_EXEC :
  479.     case TKEY_CR :
  480. /*-----------------------------------------------------------------------------
  481. **    ●●●  PLAY  ●●●
  482. -----------------------------------------------------------------------------*/
  483.         mossetpos( SW_PLAY+SWVAL ) ;
  484.         for ( flg=FALSE,c=0; c<CDDA_INFO_buf.end; c++ ) {
  485.             if ( Prginf[c] ) {
  486.                 flg = TRUE ;
  487.                 break ;
  488.             }
  489.         }
  490.         if ( Playmode == SW_PROGRAM && !flg ) {
  491. /*-----------------------------------------------------------------------------
  492. **    ﾌﾟﾛｸﾞﾗﾑﾓｰﾄﾞなのに一曲も指定されていない時には、CONTINUEﾓｰﾄﾞに移行して演奏
  493. **    する.
  494. -----------------------------------------------------------------------------*/
  495.             selectmode( SW_CONTINUE ) ;
  496.             /*    ●● PLAY SWITCH ON ●●    */
  497.             no = CDDA_switch( CDDA_SW_PLAY ) ;
  498.             if ( no ) dispplay( FALSE ) ;
  499.         } else {
  500.             /*    ●● PLAY SWITCH ON ●●    */
  501.             no = CDDA_switch( CDDA_SW_PLAY ) ;
  502.             disperrormsg( no ) ;
  503.             if ( !no ) {
  504.                 /*  演奏 OK!    */
  505.                 if ( !Flg.pause ) Flg.playon  = TRUE ;
  506.                 switch ( Playmode ) {
  507.                 case SW_PROGRAM :
  508.                     Flg.program = TRUE ;
  509.                     disptocmode( SW_PROGRAM,DUMMY ) ;
  510.                     break ;
  511.                 case SW_CONTINUE :
  512.                     if ( Flg.shuffle && !Flg.pause ) {
  513.                         Flg.shuffle = FALSE ;
  514.                         dispshuffle( FALSE ) ;
  515.                         disptocmode( SW_CONTINUE,CDDA_NOW_musicno ) ;
  516.                     }
  517.                     break ;
  518.                 case SW_SINGLE :
  519.                     checkmusic( CDDA_NOW_start ) ;
  520.                 }
  521.             } else {
  522.                 /*  演奏 NG!    */
  523.                 if ( CDDA_NOW_status != CDDA_STAT_PLAY ) {
  524.                     dispplay( FALSE ) ;
  525.                 }
  526.             }
  527.         }
  528.         disptime( CDDA_NOW_start,Timemode ) ;
  529.         Flg.pause = FALSE ;
  530.         break ;
  531.     case KEY_S :
  532. /*-----------------------------------------------------------------------------
  533. **    ●●●  SHUFFLE  ●●●
  534. -----------------------------------------------------------------------------*/
  535.         Flg.shuffle = FALSE ;
  536. /*-----------------------------------------------------------------------------
  537. **    ｼｬｯﾌﾙ指定時は、CONTINUEﾓｰﾄﾞと同じ表示とする｡
  538. -----------------------------------------------------------------------------*/
  539.         disptoc( FALSE ) ;
  540.         selectmode( SW_CONTINUE ) ;
  541.         mossetpos( SW_SHUFFLE+SWVAL ) ;
  542.         /*    ●● SHUFFLE SWITCH ON ●●    */
  543.         no = CDDA_switch( CDDA_SW_SHUFFLE ) ;
  544.         if ( !no ) {
  545.             /*  演奏 OK!    */
  546.             Flg.playon  = TRUE ;
  547.             Flg.shuffle = TRUE ;
  548.             dispshuffle( TRUE ) ;
  549.             dispplay( TRUE ) ;
  550.             checkmusic( CDDA_NOW_start ) ;
  551.             disptime( CDDA_NOW_start,Timemode ) ;
  552.         } else {
  553.             /*  演奏 NG!    */
  554.             dispshuffle( FALSE ) ;
  555.             dispplay( FALSE ) ;
  556.             disptoc( FALSE ) ;
  557.             disptime( ZERO,TM_NODISP ) ;
  558.         }
  559.     }
  560. }
  561.  
  562. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  563. void KEY_selectffrew( char key )
  564. /*=============================================================================
  565. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (FF/REW 処理)
  566. **
  567. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  568. **    < OUTPUT > : なし
  569. **    < RETURN > : なし
  570. **
  571. **    ★[CDPN.C]<event-selectffrew>と同じ処理であること.
  572. =============================================================================*/
  573. {
  574.     int        evno ;
  575.     int        no ;
  576.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  577.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  578.  
  579.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  580.  
  581. /*-----------------------------------------------------------------------------
  582. **    ｽｲｯﾁ ON 表示
  583. -----------------------------------------------------------------------------*/
  584.     dispmouse( FALSE ) ;
  585.     switch ( key ) {
  586.     case KEY_BEFORE :
  587.         evno = SW_REWMUSIC + SWVAL ;
  588.         break ;
  589.     case KEY_NEXT :
  590.         evno = SW_FFMUSIC + SWVAL ;
  591.         break ;
  592.     case KEY_F :
  593.         evno = SW_FFTIME + SWVAL ;
  594.         break ;
  595.     case KEY_R :
  596.         evno = SW_REWTIME + SWVAL ;
  597.     }
  598.     dispevent( evno,TRUE ) ;
  599.     mossetpos( evno ) ;
  600.  
  601. /*-----------------------------------------------------------------------------
  602. **    Flg.prgchk が真値だと、時間表示されないので、FALSEにし待ち時間をｸﾘｱする.
  603. -----------------------------------------------------------------------------*/
  604.     Flg.prgchk = FALSE ;
  605.     Tcount2 = PRG_WAIT + 1 ;
  606.  
  607. /*-----------------------------------------------------------------------------
  608. **    演奏中かPAUSE中でなければ、ｽｲｯﾁをOFFにして ﾘﾀｰﾝ する.
  609. -----------------------------------------------------------------------------*/
  610.     if ( CDDA_NOW_status != CDDA_STAT_PLAY &&
  611.             CDDA_NOW_status != CDDA_STAT_PAUSE ) {
  612.         dispevent( evno,FALSE ) ;
  613.         return ;
  614.     }
  615.  
  616. /*-----------------------------------------------------------------------------
  617. **    ｽｲｯﾁ 操作(実行)
  618. -----------------------------------------------------------------------------*/
  619.     switch ( key ) {
  620.     case KEY_BEFORE :
  621. /*-----------------------------------------------------------------------------
  622. **    ●●●  曲戻し  ●●●
  623. -----------------------------------------------------------------------------*/
  624.         no = CDDA_NOW_musicno ;
  625.         /*    ●● 曲戻し SWITCH ON ●●    */
  626.         CDDA_switch( CDDA_SW_REWMUSIC ) ;
  627.         if ( no != CDDA_NOW_musicno ) {
  628.             Flg.playon = TRUE ;
  629.             dispmusicno( CDDA_NOW_musicno,TRUE ) ;
  630.             if ( Playmode == SW_SINGLE ) {
  631.                 dispmusicno( no,FALSE ) ;
  632.             }
  633.         }
  634.         disptime( CDDA_NOW_musicno,Timemode ) ;
  635.         KEY_break( key ) ;
  636.         /*    ●● SWITCH 開放 ●●    */
  637.         CDDA_switch( CDDA_SW_BREAK ) ;
  638.         dispevent( evno,FALSE ) ;
  639.         break ;
  640.     case KEY_NEXT :
  641. /*-----------------------------------------------------------------------------
  642. **    ●●●  曲送り  ●●●
  643. -----------------------------------------------------------------------------*/
  644.         no = CDDA_NOW_musicno ;
  645.         /*    ●● 曲送り SWITCH ON ●●    */
  646.         CDDA_switch( CDDA_SW_FFMUSIC ) ;
  647.         if ( no != CDDA_NOW_musicno ) {
  648.             if ( Playmode == SW_PROGRAM ) {
  649.                 Flg.playon = TRUE ;
  650.                 if ( no > ZERO ) Prginf[no-1] -- ;
  651.                 if ( Prginf[no-1] <= ZERO ) dispmusicno( no,FALSE ) ;
  652.             } else {
  653.                 dispmusicno( no,FALSE ) ;
  654.             }
  655.             dispmusicno( CDDA_NOW_musicno,TRUE ) ;
  656.         }
  657.         disptime( CDDA_NOW_musicno,Timemode ) ;
  658.         KEY_break( key ) ;
  659.         /*    ●● SWITCH 開放 ●●    */
  660.         CDDA_switch( CDDA_SW_BREAK ) ;
  661.         dispevent( evno,FALSE ) ;
  662.         break ;
  663.     case KEY_F :
  664. /*-----------------------------------------------------------------------------
  665. **    ●●●  時間送り  ●●●
  666. -----------------------------------------------------------------------------*/
  667.         no = CDDA_NOW_musicno ;
  668.         /*    ●● 時間送り SWITCH ON ●●    */
  669.         CDDA_switch( CDDA_SW_FFTIME ) ;
  670.         if ( no != CDDA_NOW_musicno ) {
  671.             if ( Playmode == SW_PROGRAM ) {
  672.                 Flg.playon = TRUE ;
  673.                 if ( no > ZERO ) Prginf[no-1] -- ;
  674.                 if ( Prginf[no-1] <= ZERO ) dispmusicno( no,FALSE ) ;
  675.             } else {
  676.                 dispmusicno( no,FALSE ) ;
  677.             }
  678.             dispmusicno( CDDA_NOW_musicno,TRUE ) ;
  679.         }
  680.         disptime( CDDA_NOW_musicno,Timemode ) ;
  681.         keyrepflg = FALSE ;
  682.         do {
  683.             no = CDDA_NOW_musicno ;
  684.             /*    ●● 時間送り SWITCH ON ●●    */
  685.             if ( CDDA_switch( CDDA_SW_FFTIME ) ) break ;
  686.             if ( no != CDDA_NOW_musicno ) {
  687.                 if ( Playmode == SW_PROGRAM ) {
  688.                     Flg.playon = TRUE ;
  689.                     if ( no > ZERO ) Prginf[no-1] -- ;
  690.                     if ( Prginf[no-1] <= ZERO ) dispmusicno( no,FALSE ) ;
  691.                 } else {
  692.                     dispmusicno( no,FALSE ) ;
  693.                 }
  694.                 dispmusicno( CDDA_NOW_musicno,TRUE ) ;
  695.             }
  696.             disptime( CDDA_NOW_musicno,Timemode ) ;
  697.             if ( keyrepflg ) {
  698.                 ;                                        /*  ｷｰﾘﾋﾟｰﾄ間隔 0    */
  699.             } else {
  700.                 SOFT_timer( KEY_WAIT ) ;
  701.                 keyrepflg = TRUE ;
  702.             }
  703.             KYB_clrbuf() ;
  704.             KYB_matrix( matrix ) ;
  705.         } while ( KEY_test( matrix,key ) ) ;
  706.         KEY_break( key ) ;
  707.         KYB_clrbuf() ;
  708.         /*    ●● SWITCH 開放 ●●    */
  709.         CDDA_switch( CDDA_SW_BREAK ) ;
  710.         dispevent( evno,FALSE ) ;
  711.         break ;
  712.     case KEY_R :
  713. /*-----------------------------------------------------------------------------
  714. **    ●●●  時間戻し  ●●●
  715. -----------------------------------------------------------------------------*/
  716.         no = CDDA_NOW_musicno ;
  717.         /*    ●● 時間戻し SWITCH ON ●●    */
  718.         CDDA_switch( CDDA_SW_REWTIME ) ;
  719.         if ( no != CDDA_NOW_musicno ) {
  720.             Flg.playon = TRUE ;
  721.             dispmusicno( CDDA_NOW_musicno,TRUE ) ;
  722.             if ( Playmode == SW_SINGLE ) {
  723.                 dispmusicno( no,FALSE ) ;
  724.             }
  725.         }
  726.         keyrepflg = FALSE ;
  727.         do {
  728.             no = CDDA_NOW_musicno ;
  729.             /*    ●● 時間戻し SWITCH ON ●●    */
  730.             if ( CDDA_switch( CDDA_SW_REWTIME ) ) break ;
  731.             if ( no != CDDA_NOW_musicno ) {
  732.                 Flg.playon = TRUE ;
  733.                 dispmusicno( CDDA_NOW_musicno,TRUE ) ;
  734.                 if ( Playmode == SW_SINGLE ) {
  735.                     dispmusicno( no,FALSE ) ;
  736.                 }
  737.             }
  738.             disptime( CDDA_NOW_musicno,Timemode ) ;
  739.             if ( keyrepflg ) {
  740.                 ;                                        /*  ｷｰﾘﾋﾟｰﾄ間隔 0    */
  741.             } else {
  742.                 SOFT_timer( KEY_WAIT ) ;
  743.                 keyrepflg = TRUE ;
  744.             }
  745.             KYB_clrbuf() ;
  746.             KYB_matrix( matrix ) ;
  747.         } while ( KEY_test( matrix,key ) ) ;
  748.         KEY_break( key ) ;
  749.         KYB_clrbuf() ;
  750.         /*    ●● SWITCH 開放 ●●    */
  751.         CDDA_switch( CDDA_SW_BREAK ) ;
  752.         dispevent( evno,FALSE ) ;
  753.     }
  754. }
  755.  
  756. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  757. void KEY_selectelevol( char key )
  758. /*=============================================================================
  759. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (電子ﾎﾞﾘｭｰﾑ処理)
  760. **
  761. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  762. **    < OUTPUT > : なし
  763. **    < RETURN > : なし
  764. **
  765. **    ★[CDPN.C]<event-selectelevol>と同じ処理であること.
  766. =============================================================================*/
  767. {
  768.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  769.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  770.  
  771. /*-----------------------------------------------------------------------------
  772. **    ｽｲｯﾁ 操作(実行)
  773. -----------------------------------------------------------------------------*/
  774.     dispmouse( FALSE ) ;
  775.     switch ( key ) {
  776.     case KEY_HOME :
  777. /*-----------------------------------------------------------------------------
  778. **    ●●●  MUTE ON/OFF  ●●●
  779. -----------------------------------------------------------------------------*/
  780.         if ( Flg.mute ) {
  781.             Flg.mute = FALSE ;
  782.         } else {
  783.             Flg.mute = TRUE ;
  784.         }
  785.         dispelevol() ;
  786.         if ( Flg.mute ) {
  787.             ELEVOL_mute() ;
  788.         } else {
  789.             ELEVOL_set( ELEVOL_CD,Evol+1,Evol+1 ) ;            /*  CD        */
  790.         }
  791.         break ;
  792.     case KEY_U :
  793. /*-----------------------------------------------------------------------------
  794. **    ●●●  電子ﾎﾞﾘｭｰﾑ UP  ●●●
  795. -----------------------------------------------------------------------------*/
  796.         keyrepflg = FALSE ;
  797.         Flg.mute  = FALSE ;
  798.         do {
  799.             Evol += 4 ;
  800.             if ( Evol > ELEVOL_MAX ) Evol = ELEVOL_MAX ;
  801.             dispelevol() ;
  802.             ELEVOL_set( ELEVOL_CD,Evol+1,Evol+1 ) ;            /*  CD        */
  803.             if ( Evol == ELEVOL_MAX ) break ;
  804.             if ( keyrepflg ) {
  805.                 SOFT_timer( KEY_REPEAT ) ;            /*  ｷｰﾘﾋﾟｰﾄ間隔待ち    */
  806.             } else {
  807.                 SOFT_timer( KEY_WAIT ) ;
  808.                 keyrepflg = TRUE ;
  809.             }
  810.             KYB_clrbuf() ;
  811.             KYB_matrix( matrix ) ;
  812.         } while ( KEY_test( matrix,key ) ) ;
  813.         KEY_break( key ) ;
  814.         KYB_clrbuf() ;
  815.         break ;
  816.     case KEY_D :
  817. /*-----------------------------------------------------------------------------
  818. **    ●●●  電子ﾎﾞﾘｭｰﾑ DOWN  ●●●
  819. -----------------------------------------------------------------------------*/
  820.         keyrepflg = FALSE ;
  821.         Flg.mute  = FALSE ;
  822.         do {
  823.             Evol -= 4 ;
  824.             if ( Evol < ELEVOL_MIN ) Evol = ELEVOL_MIN ;
  825.             dispelevol() ;
  826.             ELEVOL_set( ELEVOL_CD,Evol+1,Evol+1 ) ;            /*  CD        */
  827.             if ( Evol == ELEVOL_MIN ) break ;
  828.             if ( keyrepflg ) {
  829.                 SOFT_timer( KEY_REPEAT ) ;            /*  ｷｰﾘﾋﾟｰﾄ間隔待ち    */
  830.             } else {
  831.                 SOFT_timer( KEY_WAIT ) ;
  832.                 keyrepflg = TRUE ;
  833.             }
  834.             KYB_clrbuf() ;
  835.             KYB_matrix( matrix ) ;
  836.         } while ( KEY_test( matrix,key ) ) ;
  837.         KEY_break( key ) ;
  838.         KYB_clrbuf() ;
  839.         break ;
  840.     case KEY_UNDO :
  841. /*-----------------------------------------------------------------------------
  842. **    ●●●  電子ﾎﾞﾘｭｰﾑ MAX  ●●●
  843. -----------------------------------------------------------------------------*/
  844.         Flg.mute = FALSE ;
  845.         Evol = ELEVOL_MAX ;
  846.         dispelevol() ;
  847.         ELEVOL_set( ELEVOL_CD,Evol+1,Evol+1 ) ;                /*  CD        */
  848.     }
  849. }
  850.  
  851. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  852. void KEY_selectup( void )
  853. /*=============================================================================
  854. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (前曲番号選択処理)
  855. **
  856. **    < INPUT  > : なし
  857. **    < OUTPUT > : なし
  858. **    < RETURN > : なし
  859. =============================================================================*/
  860. {
  861.     int        no ;
  862.     int        c ;
  863.  
  864. /*-----------------------------------------------------------------------------
  865. **    表示曲番号(XORno)が 0 でなければ、ﾃﾞｸﾘﾒﾝﾄ する.
  866. **    0 ならば、演奏中の曲番号を ｾｯﾄ する. 演奏中でなければ、最後の曲番号をｾｯﾄ
  867. **    する.
  868. -----------------------------------------------------------------------------*/
  869.     no = XORno ;
  870.     if ( no > ZERO ) no -- ;
  871.     if ( !XORno ) {
  872.         no = CDDA_NOW_musicno ;
  873.     }
  874.     if ( !no ) {
  875.         no = CDDA_INFO_buf.end ;
  876.     }
  877.     
  878.     c = 0 ;
  879.     while ( TRUE ) {
  880.         if ( !CDDA_data_check( no ) ) {
  881.             /*  音楽ならば...    */
  882.             dispselectmusicno( no ) ;
  883.             mossetpos( no ) ;
  884.             break ;
  885.         }
  886.         if ( no > ZERO ) no -- ;
  887.         if ( !no ) {
  888.             no = CDDA_INFO_buf.end ;
  889.         }
  890.         c ++ ;
  891.         if ( c > CDDA_INFO_buf.end ) break ;
  892.     } ;
  893. }
  894.  
  895. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  896. void KEY_selectdown( void )
  897. /*=============================================================================
  898. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (後曲番号選択処理)
  899. **
  900. **    < INPUT  > : なし
  901. **    < OUTPUT > : なし
  902. **    < RETURN > : なし
  903. =============================================================================*/
  904. {
  905.     int        no ;
  906.     int        c ;
  907.  
  908. /*-----------------------------------------------------------------------------
  909. **    表示曲番号(XORno)が 0 でなければ、ｲﾝｸﾘﾒﾝﾄ する.
  910. **    0 ならば、演奏中の曲番号を ｾｯﾄ する. 演奏中でなければ、最初の曲番号をｾｯﾄ
  911. **    する.
  912. -----------------------------------------------------------------------------*/
  913.     no = XORno ;
  914.     if ( no ) no ++ ;
  915.     if ( !XORno ) {
  916.         no = CDDA_NOW_musicno ;
  917.     }
  918.     if ( no > CDDA_INFO_buf.end || !no ) {
  919.         no = CDDA_INFO_buf.start ;
  920.     }
  921.  
  922.     c = 0 ;
  923.     while ( TRUE ) {
  924.         if ( !CDDA_data_check( no ) ) {
  925.             /*  音楽ならば...    */
  926.             dispselectmusicno( no ) ;
  927.             mossetpos( no ) ;
  928.             break ;
  929.         }
  930.         no ++ ;
  931.         if ( no > CDDA_INFO_buf.end || !no ) {
  932.             no = CDDA_INFO_buf.start ;
  933.         }
  934.         c ++ ;
  935.         if ( c > CDDA_INFO_buf.end ) break ;
  936.     } ;
  937. }
  938.  
  939. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  940. void KEY_selectright( void )
  941. /*=============================================================================
  942. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (後曲番号選択処理)
  943. **
  944. **    < INPUT  > : なし
  945. **    < OUTPUT > : なし
  946. **    < RETURN > : なし
  947. =============================================================================*/
  948. {
  949.     int        no ;
  950.     int        c ;
  951.  
  952. /*-----------------------------------------------------------------------------
  953. **    表示曲番号(XORno)が 0 でなければ、1行に表示されている曲数分加える.
  954. **    0 ならば、演奏中の曲番号を ｾｯﾄ する. 演奏中でなければ、最初の曲番号をｾｯﾄ
  955. **    する.
  956. -----------------------------------------------------------------------------*/
  957.     no = XORno ;
  958.     if ( no ) no += 20 ;
  959.     if ( !XORno ) {
  960.         no = CDDA_NOW_musicno ;
  961.     }
  962.     if ( no > CDDA_INFO_buf.end ) {
  963.         no %= 20 ;
  964.         if ( !no ) no = 20 ;
  965.     }
  966.     if ( !no ) {
  967.         no = CDDA_INFO_buf.start ;
  968.     }
  969.  
  970.     c = 0 ;
  971.     while ( TRUE ) {
  972.         if ( !CDDA_data_check( no ) ) {
  973.             /*  音楽ならば...    */
  974.             dispselectmusicno( no ) ;
  975.             mossetpos( no ) ;
  976.             break ;
  977.         }
  978.         no += 20 ;
  979.         if ( no > CDDA_INFO_buf.end ) {
  980.             no %= 20 ;
  981.             if ( !no ) no = 20 ;
  982.         }
  983.         c ++ ;
  984.         if ( c > CDDA_INFO_buf.end / 20 ) break ;
  985.     } ;
  986. }
  987.  
  988. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  989. void KEY_selectleft( void )
  990. /*=============================================================================
  991. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (後曲番号選択処理)
  992. **
  993. **    < INPUT  > : なし
  994. **    < OUTPUT > : なし
  995. **    < RETURN > : なし
  996. =============================================================================*/
  997. {
  998.     int        no ;
  999.     int        c, p ;
  1000.  
  1001. /*-----------------------------------------------------------------------------
  1002. **    表示曲番号(XORno)が 0 でなければ、1行に表示されている曲数分引く.
  1003. **    0 ならば、演奏中の曲番号を ｾｯﾄ する. 演奏中でなければ、最初の曲番号をｾｯﾄ
  1004. **    する.
  1005. -----------------------------------------------------------------------------*/
  1006.     no = XORno ;
  1007.     if ( no ) no -= 20 ;
  1008.     if ( !XORno ) {
  1009.         no = CDDA_NOW_musicno ;
  1010.     }
  1011.     if ( no < CDDA_INFO_buf.start ) {
  1012.         no += 20 ;
  1013.         p = CDDA_INFO_buf.end / 20 * 20 ;
  1014.         if ( no + p > CDDA_INFO_buf.end ) {
  1015.             if ( p ) no += ( p - 20 ) ;
  1016.         } else {
  1017.             no += p ;
  1018.         }
  1019.     }
  1020.     if ( !no ) {
  1021.         no = CDDA_INFO_buf.start ;
  1022.     }
  1023.  
  1024.     c = 0 ;
  1025.     p = CDDA_INFO_buf.end / 20 * 20 ;
  1026.     while ( TRUE ) {
  1027.         if ( !CDDA_data_check( no ) ) {
  1028.             /*  音楽ならば...    */
  1029.             dispselectmusicno( no ) ;
  1030.             mossetpos( no ) ;
  1031.             break ;
  1032.         }
  1033.         no -= 20 ;
  1034.         if ( no < CDDA_INFO_buf.start ) {
  1035.             no += 20 ;
  1036.             if ( no + p > CDDA_INFO_buf.end ) {
  1037.                 if ( p ) no += ( p - 20 ) ;
  1038.             } else {
  1039.                 no += p ;
  1040.             }
  1041.         }
  1042.         c ++ ;
  1043.         if ( c > p / 20 ) break ;
  1044.     } ;
  1045. }
  1046.  
  1047. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  1048. void KEY_selectmusic( char key )
  1049. /*=============================================================================
  1050. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (曲番号選択処理)
  1051. **
  1052. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  1053. **    < OUTPUT > : なし
  1054. **    < RETURN > : なし
  1055. =============================================================================*/
  1056. {
  1057.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1058.     char    keyrepflg ;                                /*  ｷｰﾘﾋﾟｰﾄ用ﾌﾗｸﾞ        */
  1059.  
  1060.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  1061.  
  1062. /*-----------------------------------------------------------------------------
  1063. **    ｽｲｯﾁ 操作(実行)
  1064. -----------------------------------------------------------------------------*/
  1065.     dispmouse( FALSE ) ;
  1066.     switch ( key ) {
  1067.     case KEY_UP :
  1068.         keyrepflg = FALSE ;
  1069.         do {
  1070.             KEY_selectup() ;
  1071.             if ( keyrepflg ) {
  1072.                 SOFT_timer( KEY_REPEAT ) ;            /*  ｷｰﾘﾋﾟｰﾄ間隔待ち    */
  1073.             } else {
  1074.                 SOFT_timer( KEY_WAIT ) ;
  1075.                 keyrepflg = TRUE ;
  1076.             }
  1077.             KYB_clrbuf() ;
  1078.             KYB_matrix( matrix ) ;
  1079.         } while ( KEY_test( matrix,key ) ) ;
  1080.         KEY_break( key ) ;
  1081.         KYB_clrbuf() ;
  1082.         break ;
  1083.     case KEY_DOWN :
  1084.         keyrepflg = FALSE ;
  1085.         do {
  1086.             KEY_selectdown() ;
  1087.             if ( keyrepflg ) {
  1088.                 SOFT_timer( KEY_REPEAT ) ;            /*  ｷｰﾘﾋﾟｰﾄ間隔待ち    */
  1089.             } else {
  1090.                 SOFT_timer( KEY_WAIT ) ;
  1091.                 keyrepflg = TRUE ;
  1092.             }
  1093.             KYB_clrbuf() ;
  1094.             KYB_matrix( matrix ) ;
  1095.         } while ( KEY_test( matrix,key ) ) ;
  1096.         KEY_break( key ) ;
  1097.         KYB_clrbuf() ;
  1098.         break ;
  1099.     case KEY_RIGHT :
  1100.         keyrepflg = FALSE ;
  1101.         do {
  1102.             KEY_selectright() ;
  1103.             if ( keyrepflg ) {
  1104.                 SOFT_timer( KEY_REPEAT ) ;            /*  ｷｰﾘﾋﾟｰﾄ間隔待ち    */
  1105.             } else {
  1106.                 SOFT_timer( KEY_WAIT ) ;
  1107.                 keyrepflg = TRUE ;
  1108.             }
  1109.             KYB_clrbuf() ;
  1110.             KYB_matrix( matrix ) ;
  1111.         } while ( KEY_test( matrix,key ) ) ;
  1112.         KEY_break( key ) ;
  1113.         KYB_clrbuf() ;
  1114.         break ;
  1115.     case KEY_LEFT :
  1116.         keyrepflg = FALSE ;
  1117.         do {
  1118.             KEY_selectleft() ;
  1119.             if ( keyrepflg ) {
  1120.                 SOFT_timer( KEY_REPEAT ) ;            /*  ｷｰﾘﾋﾟｰﾄ間隔待ち    */
  1121.             } else {
  1122.                 SOFT_timer( KEY_WAIT ) ;
  1123.                 keyrepflg = TRUE ;
  1124.             }
  1125.             KYB_clrbuf() ;
  1126.             KYB_matrix( matrix ) ;
  1127.         } while ( KEY_test( matrix,key ) ) ;
  1128.         KEY_break( key ) ;
  1129.         KYB_clrbuf() ;
  1130.     }
  1131. }
  1132.  
  1133. /******************************  ｷｰｲﾍﾞﾝﾄの実行  ******************************/
  1134. void KEY_selectprogramsw( char key )
  1135. /*=============================================================================
  1136. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄを実行する. (ﾌﾟﾛｸﾞﾗﾑ曲確認/削除処理)
  1137. **
  1138. **    < INPUT  > : 入力されたｷｰｱﾄﾞﾚｽ
  1139. **    < OUTPUT > : なし
  1140. **    < RETURN > : なし
  1141. **
  1142. **    ★[CDPN.C]<event-selectprogramsw>と同じ処理であること.
  1143. =============================================================================*/
  1144. {
  1145.     int        evno ;
  1146.  
  1147.     if ( CDDA_NOW_status == CDDA_STAT_NOTREADY ) return ;
  1148.  
  1149. /*-----------------------------------------------------------------------------
  1150. **    ｽｲｯﾁ ON 表示
  1151. -----------------------------------------------------------------------------*/
  1152.     dispmouse( FALSE ) ;
  1153.     switch ( key ) {
  1154.     case KEY_C :
  1155.         evno = SW_CHECK + SWVAL ;
  1156.         break ;
  1157.     case KEY_Y :
  1158.         evno = SW_CLEAR + SWVAL ;
  1159.     }
  1160.     dispevent( evno,TRUE ) ;
  1161.     mossetpos( evno ) ;
  1162.  
  1163. /*-----------------------------------------------------------------------------
  1164. **    ｽｲｯﾁ 操作(実行)
  1165. -----------------------------------------------------------------------------*/
  1166.     switch ( key ) {
  1167.     case KEY_C :
  1168.         selectprogramsw( SW_CHECK ) ;
  1169.         break ;
  1170.     case KEY_Y :
  1171.         selectprogramsw( SW_CLEAR ) ;
  1172.         break ;
  1173.     case KEY_T :
  1174.         if ( tapeselecton() ) {                /*  有効    */
  1175.             mossetpos( SW_TOTAL ) ;
  1176.             TAPE_autoselect() ;
  1177.         }
  1178.     }
  1179. }
  1180.  
  1181. /******************************  ｷｰｲﾍﾞﾝﾄのﾁｪｯｸ  ******************************/
  1182. int KEY_event( void )
  1183. /*=============================================================================
  1184. **    ｷｰﾎﾞｰﾄﾞから入力ｷｰに対応するｲﾍﾞﾝﾄをﾁｪｯｸする.
  1185. **
  1186. **    < INPUT  > : なし
  1187. **    < OUTPUT > : なし
  1188. **    < RETURN > : 終了の時 真値, それ以外は 偽値.
  1189. **
  1190. **    ｲﾍﾞﾝﾄに対応するｽｲｯﾁを表示ONにするので、必要に応じて呼び側で表示OFFにする
  1191. **    必要があります.
  1192. =============================================================================*/
  1193. {
  1194.     char    matrix[16] ;                            /*  ｷｰﾏﾄﾘｸｽ取得用        */
  1195.     char    key ;
  1196.  
  1197.      KYB_clrbuf() ;
  1198.     KYB_matrix( matrix ) ;
  1199.  
  1200.     if ( KEY_matrix_check( matrix ) ) {                /*  ｷｰ入力あり            */
  1201.         if ( CDDA_NOW_status == CDDA_STAT_STOP ||
  1202.                 CDDA_NOW_status == CDDA_STAT_NOTREADY ) {
  1203.             Noaflg = TRUE ;
  1204.             SNDPLAY_stop( STOP_CH ) ;
  1205.             Tcount3 = NOA_WAIT + 1 ;
  1206.         }
  1207.     }
  1208.  
  1209.     key = FALSE ;
  1210.     if ( KEY_test( matrix,KEY_CTRL ) ) {            /*  CTRL ｷｰ ON        */
  1211.         if ( KEY_test( matrix,KEY_Q ) ) {                /*  End            */
  1212.             key = KEY_Q ;
  1213.             KEY_selectexit( key ) ;
  1214.             return( TRUE ) ;
  1215.         } else if ( KEY_test( matrix,KEY_E ) ) {        /*  End            */
  1216.             key = KEY_E ;
  1217.             KEY_selectexit( key ) ;
  1218.             return( TRUE ) ;
  1219.         } else if ( KEY_test( matrix,KEY_S ) ) {        /*  Suffle        */
  1220.             key = KEY_S ;
  1221.             KEY_selectplay( key ) ;
  1222.         } else if ( KEY_test( matrix,KEY_R ) ) {        /*  Repeat        */
  1223.             key = KEY_R ;
  1224.             KEY_selectmode( key ) ;
  1225.         } else if ( KEY_test( matrix,KEY_C ) ) {        /*  Check        */
  1226.             key = KEY_C ;
  1227.             KEY_selectprogramsw( key ) ;
  1228.         } else if ( KEY_test( matrix,KEY_Y ) ) {        /*  Clear        */
  1229.             key = KEY_Y ;
  1230.             KEY_selectprogramsw( key ) ;
  1231.         } else if ( KEY_test( matrix,KEY_T ) ) {        /*  Tape select    */
  1232.             key = KEY_T ;
  1233.             KEY_selectprogramsw( key ) ;
  1234.         }
  1235.  
  1236.     } else {                                        /*  CTRL ｷｰ OFF        */
  1237.         if ( KEY_test( matrix,KEY_CR ) ) {                /*  PLAY        */
  1238.             key = KEY_CR ;
  1239.             KEY_selectplay( key ) ;
  1240.         } else if ( KEY_test( matrix,KEY_EXEC ) ) {        /*  PLAY        */
  1241.             key = KEY_EXEC ;
  1242.             KEY_selectplay( key ) ;
  1243.         } else if ( KEY_test( matrix,TKEY_CR ) ) {        /*  PLAY        */
  1244.             key = TKEY_CR ;
  1245.             KEY_selectplay( key ) ;
  1246.         } else if ( KEY_test( matrix,KEY_BEFORE ) ) {    /*  前曲        */
  1247.             key = KEY_BEFORE ;
  1248.             KEY_selectffrew( key ) ;
  1249.         } else if ( KEY_test( matrix,KEY_NEXT ) ) {        /*  次曲        */
  1250.             key = KEY_NEXT ;
  1251.             KEY_selectffrew( key ) ;
  1252.         } else if ( KEY_test( matrix,KEY_F ) ) {        /*  FF            */
  1253.             key = KEY_F ;
  1254.             KEY_selectffrew( key ) ;
  1255.         } else if ( KEY_test( matrix,KEY_R ) ) {        /*  REW            */
  1256.             key = KEY_R ;
  1257.             KEY_selectffrew( key ) ;
  1258.         } else if ( KEY_test( matrix,KEY_SPACE ) ) {    /*  PAUSE        */
  1259.             key = KEY_SPACE ;
  1260.             KEY_selectstop( key ) ;
  1261.         } else if ( KEY_test( matrix,TKEY_EQU ) ) {        /*  PAUSE        */
  1262.             key = TKEY_EQU ;
  1263.             KEY_selectstop( key ) ;
  1264.         } else if ( KEY_test( matrix,KEY_T ) ) {        /*  Time        */
  1265.             key = KEY_T ;
  1266.             KEY_selectmode( key ) ;
  1267.         } else if ( KEY_test( matrix,KEY_P ) ) {        /*  Program        */
  1268.             key = KEY_P ;
  1269.             KEY_selectmode( key ) ;
  1270.         } else if ( KEY_test( matrix,KEY_S ) ) {        /*  Single        */
  1271.             key = KEY_S ;
  1272.             KEY_selectmode( key ) ;
  1273.         } else if ( KEY_test( matrix,KEY_C ) ) {        /*  Continue    */
  1274.             key = KEY_C ;
  1275.             KEY_selectmode( key ) ;
  1276.         } else if ( KEY_test( matrix,KEY_HOME ) ) {        /*  MUTE ON/OFF    */
  1277.             key = KEY_HOME ;
  1278.             KEY_selectelevol( key ) ;
  1279.         } else if ( KEY_test( matrix,KEY_U ) ) {        /*  Vol. UP        */
  1280.             key = KEY_U ;
  1281.             KEY_selectelevol( key ) ;
  1282.         } else if ( KEY_test( matrix,KEY_D ) ) {        /*  Vol. DOWN    */
  1283.             key = KEY_D ;
  1284.             KEY_selectelevol( key ) ;
  1285.         } else if ( KEY_test( matrix,KEY_UNDO ) ) {        /*  Vol. MAX    */
  1286.             key = KEY_UNDO ;
  1287.             KEY_selectelevol( key ) ;
  1288.         } else if ( KEY_test( matrix,KEY_UP ) ) {        /*  CUR up        */
  1289.             key = KEY_UP ;
  1290.             KEY_selectmusic( key ) ;
  1291.         } else if ( KEY_test( matrix,KEY_DOWN ) ) {        /*  CUR down    */
  1292.             key = KEY_DOWN ;
  1293.             KEY_selectmusic( key ) ;
  1294.         } else if ( KEY_test( matrix,KEY_RIGHT ) ) {    /*  CUR right    */
  1295.             key = KEY_RIGHT ;
  1296.             KEY_selectmusic( key ) ;
  1297.         } else if ( KEY_test( matrix,KEY_LEFT ) ) {        /*  CUR left    */
  1298.             key = KEY_LEFT ;
  1299.             KEY_selectmusic( key ) ;
  1300.         } else if ( KEY_test( matrix,KEY_ESC ) ) {        /*  STOP        */
  1301.             key = KEY_ESC ;
  1302.             KEY_selectstop( key ) ;
  1303.         } else if ( KEY_test( matrix,KEY_BREAK ) ) {    /*  EXIT        */
  1304.             key = KEY_BREAK ;
  1305.             KEY_selectexit( key ) ;
  1306.             return( TRUE ) ;
  1307.         }
  1308.     }
  1309.     KEY_break( key ) ;
  1310.     dispmouse( TRUE ) ;
  1311.  
  1312.     return( FALSE ) ;
  1313. }
  1314.  
  1315.